/* eslint-disable */
/* prettier-ignore */
// @ts-nocheck

export type Method =
  | 'get'
  | 'post'
  | 'delete'
  | 'put'
  | 'patch'
  | 'head'
  | 'options'

export type PathWrapper<
  Paths,
  Keys extends keyof Paths = keyof Paths,
  M extends Method = Method
> = {
  [K in Keys]: {
    url: K
    method: keyof Paths[K] & M
    op: Paths[K][keyof Paths[K] & M]
  }
}

export type Path<
  Paths,
  URL extends keyof Paths,
  M extends Method = Method
> = Pick<PathWrapper<Paths, URL, M>, URL>[URL]

export type ApiParameter<
  Paths,
  URL extends keyof Paths,
  M extends Method = Method
> = Path<Paths, URL, M>['op'] extends {
  parameters?: {
    query?: infer Q
    body?: infer B
    path?: infer P
    formData?: infer F
  }
  requestBody?: {
    content: {
      'application/json': infer RB
    }
  }
}
  ? P & Q & (B extends Record<string, unknown> ? B[keyof B] : unknown) & F & RB
  : Record<string, any> | void

export type ApiReturn<
  Paths,
  URL extends keyof Paths,
  M extends Method = Method,
  STATE extends number = 200
> = Path<Paths, URL, M>['op'] extends {
  responses: infer R
}
  ? {
      [RK in keyof R]: R[RK] extends { schema?: infer S }
        ? S
        : R[RK] extends { content: { 'application/json': infer C } }
        ? C
        : RK extends 'default'
        ? R[RK]
        : unknown
    }[keyof R & STATE]
  : never

export type API<
  Paths,
  URL extends keyof Paths,
  M extends Method = Method,
  STATE extends number = 200
> = (
  params: ApiParameter<Paths, URL, M>,
  ...args: any
) => Promise<ApiReturn<Paths, URL, M, STATE>>

export type PromiseFn = (...args: any) => Promise<any>

export type CommonAPI<
  T extends keyof paths,
  M extends Method = Method,
  S extends number = 200
> = API<paths, T, M, S>

export type CommonParams<
  T extends keyof paths,
  M extends Method = Method
> = ApiParameter<paths, T, M>

export type CommonReturn<
  T extends keyof paths,
  M extends Method = Method,
  STATE extends number = 200
> = ApiReturn<paths, T, M, STATE>

export type CommonReturnListItem<
  T extends keyof paths,
  M extends Method = Method,
  K extends string = 'list',
  STATE extends number = 200
> = CommonReturn<T, M, STATE> extends { [Key in K]?: Array<infer R> }
  ? R
  : never
/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
  "/api/acme-account": {
    /** 创建ACME账户 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.CreateACMEAccountRequest": definitions["api.CreateACMEAccountRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 删除ACME账户 */
    delete: {
      parameters: {
        body: {
          /** body */
          "api.DeleteACMEAccountRequest": definitions["api.DeleteACMEAccountRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/acme-account/query": {
    /** 查询ACME账户 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryACMEAccountResponse"];
        };
      };
    };
  };
  "/api/captcha/image": {
    /** 获取图片验证码 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetImageCaptchaResponse"];
        };
      };
    };
  };
  "/api/captcha/verify": {
    /** 验证图片验证码 */
    post: {
      parameters: {
        body: {
          /** 验证码请求参数 */
          request: definitions["api.CheckImageCaptchaRequest"];
        };
      };
      responses: {
        /** 成功验证 */
        200: {
          schema: definitions["api.GetImageCaptchaResponse"];
        };
      };
    };
  };
  "/api/cert": {
    /** 获取证书 */
    get: {
      parameters: {
        query: {
          /** 证书id */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CertInfo"];
        };
      };
    };
  };
  "/api/cert/apply-log": {
    /** 获取申请日志证书日志 */
    get: {
      parameters: {
        query: {
          /** 证书id */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetCertApplyLogResponse"];
        };
      };
    };
  };
  "/api/cert/lookup-cname": {
    /** 查询CNAME */
    get: {
      parameters: {
        query: {
          /** 站点域名 */
          site_domain: string;
          /** 站点ID */
          site_id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.LookupCNAMEResponse"];
        };
      };
    };
  };
  "/api/cert/obtain": {
    /** 申请证书 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.ObtainCertRequest": definitions["api.ObtainCertRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.ObtainCertResponse"];
        };
      };
    };
  };
  "/api/cert/query": {
    /** 查询证书 */
    get: {
      parameters: {
        query: {
          /** 申请结果(1:正常, 2:失败, 3:申请中) */
          apply_result?: 1 | 2 | 3;
          /** 申请结束时间 */
          created_at_end?: number;
          /** 申请开始时间 */
          created_at_start?: number;
          limit?: number;
          offset?: number;
          order?: "asc" | "desc";
          /** 站点域名关键字 */
          site_domain_keyword?: string;
          sort?: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryCertResponse"];
        };
      };
    };
  };
  "/api/cert/upload": {
    /** 上传证书 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.UploadCertRequest": definitions["api.UploadCertRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CertInfo"];
        };
      };
    };
  };
  "/api/config/default-node-cache-config": {
    /** 获取默认节点缓存配置 */
    get: {
      responses: {
        /** 成功 */
        200: {
          schema: definitions["api.GetDefaultNodeCacheConfigResponse"];
        };
      };
    };
    /** 设置默认节点缓存配置 */
    put: {
      parameters: {
        body: {
          /** 配置值 */
          value: definitions["api.SetDefaultNodeCacheConfigRequest"];
        };
      };
      responses: {
        /** 成功 */
        200: {
          schema: { [key: string]: unknown };
        };
      };
    };
  };
  "/api/config/http-ports": {
    /** 获取 HTTP 监听端口 */
    get: {
      parameters: {
        body: {
          /** 配置值 */
          value: definitions["api.GetHTTPPortsRequest"];
        };
      };
      responses: {
        /** 成功 */
        200: {
          schema: definitions["api.GetHTTPPortsResponse"];
        };
      };
    };
    /** 设置 HTTP 监听端口 */
    put: {
      parameters: {
        body: {
          /** 配置值 */
          value: definitions["api.SetHTTPPortsRequest"];
        };
      };
      responses: {
        /** 成功 */
        200: {
          schema: { [key: string]: unknown };
        };
      };
    };
  };
  "/api/config/mgr-addr": {
    /** 获取管理端地址 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetMGRAddrResponse"];
        };
      };
    };
    /** 设置管理端地址 */
    put: {
      parameters: {
        body: {
          /** 配置值 */
          value: definitions["api.SetMGRAddrRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/config/preset-cache-rule": {
    /** 获取预设缓存规则 */
    get: {
      responses: {
        /** 成功 */
        200: {
          schema: definitions["api.GetPresetCacheRuleResponse"];
        };
      };
    };
    /** 设置预设缓存规则 */
    put: {
      parameters: {
        body: {
          /** 配置值 */
          value: definitions["api.SetPresetCacheRuleRequest"];
        };
      };
      responses: {
        /** 成功 */
        200: {
          schema: { [key: string]: unknown };
        };
      };
    };
  };
  "/api/license": {
    /** 获取授权信息 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetLicenseResponse"];
        };
      };
    };
  };
  "/api/license/bind": {
    /** 绑定授权 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.BindLicenseRequest": definitions["api.BindLicenseRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.BindLicenseResponse"];
        };
      };
    };
  };
  "/api/license/refresh": {
    /** 刷新授权 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.RefreshLicenseRequest": definitions["api.RefreshLicenseRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.RefreshLicenseResponse"];
        };
      };
    };
  };
  "/api/license/replace-bind": {
    /** 换绑授权 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.ReplaceBindLicenseRequest": definitions["api.ReplaceBindLicenseRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.ReplaceBindLicenseResponse"];
        };
      };
    };
  };
  "/api/license/unbind": {
    /** 解绑授权 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.UnbindLicenseRequest": definitions["api.UnbindLicenseRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UnbindLicenseResponse"];
        };
      };
    };
  };
  "/api/login": {
    /** 登录 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.LoginRequest": definitions["api.LoginRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.LoginResponse"];
        };
      };
    };
  };
  "/api/node": {
    /** 获取节点 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetNodeResponse"];
        };
      };
    };
    /** 更新节点, 增量更新接口，以下字段除id外， 可任意组合 */
    put: {
      parameters: {
        body: {
          /** 更新节点 */
          req: definitions["api.UpdateNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 创建节点 */
    post: {
      parameters: {
        body: {
          /** 创建节点 */
          req: definitions["api.CreateNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 删除节点 */
    delete: {
      parameters: {
        body: {
          /** 删除节点 */
          id: definitions["api.DeleteNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/node/cascade_region_list": {
    /** 获取级联区域列表 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CascadeListResponse"];
        };
      };
    };
  };
  "/api/node/control": {
    /** 控制节点 */
    post: {
      parameters: {
        body: {
          /** 控制节点的请求参数，包括节点ID列表，控制类型以及额外参数 */
          req: definitions["api.ControlNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/node/install-command": {
    /** 获取安装命令 */
    get: {
      parameters: {
        query: {
          /** 节点id */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetNodeVersionInstallCommandResponse"];
        };
      };
    };
  };
  "/api/node/installer": {
    /** 获取安装脚本 */
    get: {
      parameters: {
        query: {
          /** 节点id */
          id: string;
        };
      };
      responses: {
        /** Shell script file (.sh) */
        200: {
          schema: string;
        };
      };
    };
  };
  "/api/node/query": {
    /** 查询节点 */
    get: {
      parameters: {
        body: {
          /** 查询节点 */
          req: definitions["api.QueryNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryNodeResponse"];
        };
      };
    };
  };
  "/api/node/register": {
    /** 注册节点 */
    post: {
      parameters: {
        body: {
          /** 注册节点 */
          req: definitions["nodectl.FormattedInfo"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/node/simple-list": {
    /** 获取节点简单信息 */
    get: {
      parameters: {
        body: {
          /** 获取节点简单信息 */
          req: definitions["api.GetSimpleNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.SimpleNode"][];
        };
      };
    };
  };
  "/api/node/tree-with-region": {
    /** 获取节点区域树 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetNodeTreeWithRegionResponse"];
        };
      };
    };
  };
  "/api/node/update_cascade_region": {
    /** 更新节点级联区域 */
    put: {
      parameters: {
        body: {
          /** 更新节点级联区域 */
          req: definitions["api.CascadeNodeUpdate"][];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/node/version/latest": {
    /** 获取最新版本 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetLatestVersionResponse"];
        };
      };
    };
  };
  "/api/node/version/switch": {
    /** 切换版本 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.SwitchNodeVersionRequest": definitions["api.SwitchNodeVersionRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/resolve/dns-api": {
    /** 更新DNS API */
    put: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.UpdateDNSApiRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UpdateDNSApiResponse"];
        };
      };
    };
    /** 创建DNS API */
    post: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.CreateDNSApiRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CreateDNSApiResponse"];
        };
      };
    };
    /** 删除DNS API */
    delete: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.DeleteDNSApiRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.DeleteDNSApiResponse"];
        };
      };
    };
  };
  "/api/resolve/dns-apis": {
    /** 查询DNS API */
    get: {
      parameters: {
        query: {
          /** 0-100 */
          limit?: number;
          /** 名称关键字 */
          name_keyword?: string;
          offset?: number;
          order?: "asc" | "desc";
          sort?: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryDNSApiResponse"];
        };
      };
    };
  };
  "/api/resolve/domain": {
    /** 更新解析域名 */
    put: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.UpdateResolveDomainRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UpdateDNSApiResponse"];
        };
      };
    };
    /** 创建解析域名 */
    post: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.CreateResolveDomainRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CreateDNSApiResponse"];
        };
      };
    };
    /** 删除解析域名 */
    delete: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.DeleteResolveDomainRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.DeleteResolveDomainResponse"];
        };
      };
    };
  };
  "/api/resolve/domains": {
    /** 查询解析域名 */
    get: {
      parameters: {
        query: {
          /** 0-100 */
          limit?: number;
          name_keyword?: string;
          offset?: number;
          order?: "asc" | "desc";
          sort?: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryResolveDomainResponse"];
        };
      };
    };
  };
  "/api/resolve/region": {
    /** 更新区域 */
    put: {
      parameters: {
        body: {
          /** 请求参数 */
          data: definitions["api.UpdateResolveRegionRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UpdateDNSApiResponse"];
        };
      };
    };
    /** 创建区域 */
    post: {
      parameters: {
        body: {
          /** 请求参数 */
          data: definitions["api.CreateResolveRegionRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CreateDNSApiResponse"];
        };
      };
    };
    /** 删除区域 */
    delete: {
      parameters: {
        body: {
          /** 请求参数 */
          data: definitions["api.DeleteResolveRegionRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.DeleteResolveRegionResponse"];
        };
      };
    };
  };
  "/api/resolve/region/node-bindings": {
    /** 查询节点绑定 */
    get: {
      parameters: {
        query: {
          limit?: number;
          offset?: number;
          /** 区域ID */
          region_id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryResolveNodeBindingResponse"];
        };
      };
    };
  };
  "/api/resolve/region/site-bindings": {
    /** 查询站点区域绑定信息 */
    get: {
      parameters: {
        query: {
          limit?: number;
          offset?: number;
          region_id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryResolveSiteBindingResponse"];
        };
      };
    };
  };
  "/api/resolve/regions": {
    /** 查询区域列表 */
    get: {
      parameters: {
        query: {
          domain_keyword?: string;
          /** 0-100 */
          limit?: number;
          name_keyword?: string;
          offset?: number;
          order?: "asc" | "desc";
          sort?: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryResolveRegionResponse"];
        };
      };
    };
  };
  "/api/site": {
    /** 获取站点基本信息 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetSiteBaseResponse"];
        };
      };
    };
    /** 更新站点基本信息 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteBaseRequest": definitions["api.UpdateSiteBaseRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 创建站点 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.CreateSiteRequest": definitions["api.CreateSiteRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CreateSiteResponse"];
        };
      };
    };
    /** 删除站点 */
    delete: {
      parameters: {
        body: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/authorization": {
    /** 获取站点鉴权配置 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetSiteAuthorizationResponse"];
        };
      };
    };
    /** 更新站点鉴权配置 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteAuthorizationRequest": definitions["api.UpdateSiteAuthorizationRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/batch-purge": {
    /** 批量清理全站缓存请求 */
    post: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.BatchPurgeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/batch-update-group": {
    /** 批量更新站点组 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.BatchUpdateGroupRequest": definitions["api.BatchUpdateGroupRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/batch-update-region": {
    /** 批量更新站点区域 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.BatchUpdateRegionRequest": definitions["api.BatchUpdateRegionRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/cache-config": {
    /** 获取站点缓存配置 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetCacheConfigResponse"];
        };
      };
    };
    /** 更新站点缓存配置 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateCacheConfigRequest": definitions["api.UpdateCacheConfigRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/cert": {
    /** 获取站点证书 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetSiteCertResponse"];
        };
      };
    };
    /** 更新站点证书 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteCertRequest": definitions["api.UpdateSiteCertRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/cert/hsts": {
    /** 更新站点hsts配置 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateHSTSRequest": definitions["api.UpdateHSTSRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/compression": {
    /** 获取站点压缩配置 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["types.SiteCompression"];
        };
      };
    };
    /** 更新站点压缩配置 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteCompressionRequest": definitions["api.UpdateSiteCompressionRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/conversion-rule": {
    /** 获取转换规则 */
    get: {
      parameters: {
        query: {
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.ConversionRule"];
        };
      };
    };
    /** 更新转换规则 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateConversionRuleRequest": definitions["api.UpdateConversionRuleRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 创建转换规则 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.CreateConversionRuleRequest": definitions["api.CreateConversionRuleRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 删除转换规则 */
    delete: {
      parameters: {
        body: {
          /** body */
          "api.DeleteConversionRuleRequest": definitions["api.DeleteConversionRuleRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/conversion-rule/priority": {
    /** 更新转换规则优先级 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateConversionRulePriorityRequest": definitions["api.UpdateConversionRulePriorityRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/conversion-rule/query": {
    /** 查询转换规则 */
    get: {
      parameters: {
        query: {
          /** 申请结束时间 */
          created_at_end?: number;
          /** 申请开始时间 */
          created_at_start?: number;
          limit?: number;
          name_keyword?: string;
          offset?: number;
          order?: "asc" | "desc";
          /** 站点ID */
          site_id: string;
          sort?: string;
          /** 类型(1:URI, 2:请求头, 3:响应头) */
          type?: 1 | 2 | 3;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryConversionRuleResponse"];
        };
      };
    };
  };
  "/api/site/conversion-rule/status": {
    /** 更新转换规则状态 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateConversionRuleStatusRequest": definitions["api.UpdateConversionRuleStatusRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/hotlink-protection": {
    /** 获取站点防盗链配置 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetSiteHotlinkProtectionResponse"];
        };
      };
    };
    /** 更新站点防盗链配置 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteHotlinkProtectionRequest": definitions["api.UpdateSiteHotlinkProtectionRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/origin-server": {
    /** 获取站点回源信息 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetSiteOriginServerResponse"];
        };
      };
    };
    /** 更新站点回源信息 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteOriginServerRequest": definitions["api.UpdateSiteOriginServerRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/purge": {
    /** 站点缓存清除请求 */
    post: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.SitePurgeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/query": {
    /** 查询站点 */
    get: {
      parameters: {
        query: {
          /** 站点域名 */
          domain?: string;
          /** 站点组ID */
          group_id?: string;
          /** 区域ID */
          region_id?: string;
          /** 站点状态 */
          status?: "1" | "2";
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QuerySiteResponse"];
        };
      };
    };
  };
  "/api/site/resolve-status": {
    /** 更新站点解析状态 */
    put: {
      parameters: {
        body: {
          /** 请求参数 */
          request: definitions["api.UpdateSiteResolveStatusRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UpdateSiteResolveStatusResponse"];
        };
      };
    };
  };
  "/api/site/search-engine": {
    /** 获取站点搜索引擎配置 */
    get: {
      parameters: {
        query: {
          /** 站点ID */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetSiteSearchEngineResponse"];
        };
      };
    };
    /** 更新站点搜索引擎配置 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateSiteSearchEngineRequest": definitions["api.UpdateSiteSearchEngineRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/site/simple-list": {
    /** 获取站点列表(只有ID和域名) */
    get: {
      parameters: {
        query: {
          /** 区域ID */
          region_id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.SiteSimpleList"][];
        };
      };
    };
  };
  "/api/site/site-group": {
    /** 获取站点组列表 */
    get: {
      parameters: {
        body: {
          /** body */
          "api.QuerySiteGroupRequest": definitions["api.QuerySiteGroupRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QuerySiteGroupResponse"];
        };
      };
    };
    /** 更新站点组 */
    put: {
      parameters: {
        path: {
          /** id */
          id: string;
        };
        body: {
          /** body */
          "api.UpdateSiteGroupRequest": definitions["api.UpdateSiteGroupRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: unknown;
        };
      };
    };
    /** 创建站点组 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.CreateSiteGroupRequest": definitions["api.CreateSiteGroupRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.CreateSiteGroupResponse"];
        };
      };
    };
    /** 删除站点组 */
    delete: {
      parameters: {
        body: {
          /** body */
          "api.DeleteSiteGroupRequest": definitions["api.DeleteSiteGroupRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: unknown;
        };
      };
    };
  };
  "/api/statistic/node/connection": {
    /** 连接数 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.StatisticNodeCommonResponse"];
        };
      };
    };
  };
  "/api/statistic/node/cpu-used-percent": {
    /** CPU使用率 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.StatisticNodeCommonResponse"];
        };
      };
    };
  };
  "/api/statistic/node/down-bandwidth": {
    /** 带宽下行 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.StatisticNodeCommonResponse"];
        };
      };
    };
  };
  "/api/statistic/node/mem-used-percent": {
    /** 内存使用率 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.StatisticNodeCommonResponse"];
        };
      };
    };
  };
  "/api/statistic/node/up-bandwidth": {
    /** 带宽上行 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.StatisticNodeCommonResponse"];
        };
      };
    };
  };
  "/api/statistic/node/waf-info": {
    /** 节点waf概览 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.WafInfoResponse"];
        };
      };
    };
  };
  "/api/statistic/node/waf-list": {
    /** 安全分析-概览 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticNodeCommonRequest": definitions["api.StatisticNodeCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.WafRuleResponse"];
        };
      };
    };
  };
  "/api/statistic/node/waf-log": {
    /** 日志明细 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.WafNodeLogRequest": definitions["api.WafNodeLogRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.WafNodeLogResponse"];
        };
      };
    };
  };
  "/api/statistic/overview": {
    /** 首页概览 */
    post: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.OverviewResponse"];
        };
      };
    };
  };
  "/api/statistic/site/bandwidth": {
    /** 流量分析-带宽 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.SiteBandwidthResponse"];
        };
      };
    };
  };
  "/api/statistic/site/hit-rate": {
    /** 流量分析-命中率 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.SiteHitRateResponse"];
        };
      };
    };
  };
  "/api/statistic/site/request-count": {
    /** 流量分析-请求次数 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.SiteRequestCountResponse"];
        };
      };
    };
  };
  "/api/statistic/site/summary": {
    /** 流量分析-流量汇总 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.TrafficSummaryInfoResponse"];
        };
      };
    };
  };
  "/api/statistic/site/traffic": {
    /** 流量分析-流量 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.SiteTrafficResponse"];
        };
      };
    };
  };
  "/api/statistic/site/waf-info": {
    /** 安全分析-概览 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.WafInfoResponse"];
        };
      };
    };
  };
  "/api/statistic/site/waf-list": {
    /** 安全分析-规则曲线 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.StatisticSiteCommonRequest": definitions["api.StatisticSiteCommonRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.WafRuleResponse"];
        };
      };
    };
  };
  "/api/statistic/site/waf-log": {
    /** 日志明细 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.WafSiteLogRequest": definitions["api.WafSiteLogRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.WafSiteLogResponse"];
        };
      };
    };
  };
  "/api/system/install": {
    /** 安装系统 */
    post: {
      parameters: {
        body: {
          /** 安装系统请求 */
          req: definitions["api.InstallRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/system/update-status": {
    /** 检查更新状态 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["types.UpdateInfo"];
        };
      };
    };
  };
  "/api/system/version": {
    /** 获取版本 */
    get: {
      parameters: {
        query: {
          /** 是否刷新缓存 */
          refresh?: boolean;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.VersionResponse"];
        };
      };
    };
    /** 更新版本 */
    put: {
      parameters: {
        body: {
          /** 更新版本请求 */
          req: definitions["api.UpdateVersionRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/user": {
    /** 获取用户信息 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetUserResponse"];
        };
      };
    };
    /** 更新用户信息 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.UpdateUserRequest": definitions["api.UpdateUserRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UpdateUserResponse"];
        };
      };
    };
  };
  "/api/user/password": {
    /** 修改用户密码 */
    post: {
      parameters: {
        body: {
          /** body */
          "api.UpdateUserPasswordRequest": definitions["api.UpdateUserPasswordRequest"];
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.UpdateUserPasswordResponse"];
        };
      };
    };
  };
  "/api/waf": {
    /** 获取WAF */
    get: {
      parameters: {
        query: {
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.GetWAFResponse"];
        };
      };
    };
    /** 更新WAF */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateWAFRequest": definitions["api.UpdateWAFRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 创建WAF */
    post: {
      parameters: {
        body: {
          /** body */
          "api.CreateWAFRequest": definitions["api.CreateWAFRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
    /** 删除WAF */
    delete: {
      parameters: {
        body: {
          /** body */
          "api.DeleteWAFRequest": definitions["api.DeleteWAFRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/waf/bind": {
    /** 修改绑定WAF */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateWAFBindRequest": definitions["api.UpdateWAFBindRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/waf/bind-node": {
    /** 删除WAF绑定的节点 */
    delete: {
      parameters: {
        body: {
          /** body */
          "api.DeleteWAFBindNodeRequest": definitions["api.DeleteWAFBindNodeRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/waf/bind-node/list": {
    /** 获取绑定WAF的节点ID */
    get: {
      parameters: {
        query: {
          /** wafid */
          id: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.ListWAFBindNodeIDResponse"];
        };
      };
    };
  };
  "/api/waf/condition/query": {
    /** 查询WAF条件 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryWAFConditionResponse"];
        };
      };
    };
  };
  "/api/waf/node-bind": {
    /** 添加节点绑定WAF */
    post: {
      parameters: {
        body: {
          /** body */
          "api.AddNodeWAFBindRequest": definitions["api.AddNodeWAFBindRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/waf/node-unbind": {
    /** 删除节点绑定WAF */
    delete: {
      parameters: {
        body: {
          /** body */
          "api.DeleteNodeWAFBindRequest": definitions["api.DeleteNodeWAFBindRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/waf/priority": {
    /** 更新WAF优先级 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateWAFPriorityRequest": definitions["api.UpdateWAFPriorityRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/api/waf/query": {
    /** 查询WAF */
    get: {
      parameters: {
        query: {
          /** 动作(1:拦截, 2:跳过, 3:观察, 4:js质询, 5:交互式质询) */
          action?: 1 | 2 | 3 | 4 | 5;
          /** 绑定id(站点时必传) */
          bind_id?: string;
          /** ID精准搜索 */
          id?: string;
          limit?: number;
          /** 模块(1:自定义, 2:速率限制, 3:白名单) */
          module?: 1 | 2 | 3;
          /** 名称关键字 */
          name_keyword?: string;
          offset?: number;
          order?: "asc" | "desc";
          /** 范围(2:站点, 3:节点) */
          scope?: 1 | 2 | 3;
          sort?: string;
          /** 非绑定id */
          unbind_id?: string;
        };
      };
      responses: {
        /** OK */
        200: {
          schema: definitions["api.QueryWAFResponse"];
        };
      };
    };
  };
  "/api/waf/status": {
    /** 更新WAF状态 */
    put: {
      parameters: {
        body: {
          /** body */
          "api.UpdateWAFStatusRequest": definitions["api.UpdateWAFStatusRequest"];
        };
      };
      responses: {
        /** OK */
        200: unknown;
      };
    };
  };
  "/captcha/pre-check": {
    /** 返回是否需要验证码，用于前端判断是否需要展示验证码输入 */
    get: {
      responses: {
        /** OK */
        200: {
          schema: definitions["api.NeedCaptchaResponse"];
        };
      };
    };
  };
}

export interface definitions {
  "api.ACMEAccount": {
    /** @description 算法(1:EC256, 2:EC384, 3:RSA2048, 4:RSA3072, 5:RSA4096) */
    algorithm?: definitions["constant.CertAlgorithm"];
    /** @description 账号类型(1:Let's Encrypt, 2:ZeroSSL) */
    brand?: definitions["constant.CertBrand"];
    /** @description 创建时间 */
    created_at?: number;
    /** @description 邮箱 */
    email?: string;
    /** @description id */
    id?: string;
    /** @description url */
    url?: string;
  };
  "api.AddNodeWAFBindRequest": {
    /** @description nodeid */
    id: string;
    /**
     * @description 模块(1:自定义, 2:速率限制, 3:白名单)
     * @enum {undefined}
     */
    module?: 1 | 2 | 3;
    /** @description wafid */
    waf_ids: string[];
  };
  "api.BatchPurgeRequest": {
    /** @description 站点ID列表 */
    ids: string[];
  };
  "api.BatchUpdateGroupRequest": {
    /** @description 组ID 默认分组传-1  0表示全部分组 */
    group_id: string;
    /** @description 站点ID列表 */
    ids: string[];
  };
  "api.BatchUpdateRegionRequest": {
    /** @description 站点ID列表 */
    ids: string[];
    /** @description 区域ID */
    region_id: string;
  };
  "api.BindLicenseRequest": {
    /** @description 授权码 */
    key: string;
  };
  "api.BindLicenseResponse": {
    /** @description 授权到期时间 */
    expired_at?: number;
    /** @description 授权码 */
    key?: string;
    /** @description 失败原因 */
    reason?: string;
    /** @description 授权状态 0-未授权 1-正常 2-异常 3-异常（不合法）4-到期 */
    status?: definitions["constant.LicenseStatus"];
  };
  "api.CascadeListResponse": {
    /** @description List 区域列表 */
    list?: definitions["api.CascadeRegionDetail"][];
  };
  "api.CascadeNodeDetail": {
    /** @description ID 节点id */
    id?: string;
    /** @description 节点ip */
    ips?: string[];
    /** @description Name 节点名称 */
    name?: string;
    /** @description 区域ID */
    region_id?: string;
    /** @description ResolveStatus 解析状态 1.已解析 2.未解析 0.未解析 */
    resolve_status?: definitions["constant.DNSResolveStatus"];
    /** @description Status 节点运行状态  1 运行 2 异常 3 停止 4 离线 */
    status?: definitions["nodectl.NodeSynthStatus"];
  };
  "api.CascadeNodeUpdate": {
    /**
     * @description 级联级别
     * @enum {undefined}
     */
    cascade_level?: 1 | 2;
    /** @description ID 节点id */
    id: string;
    /** @description 节点区域 */
    region_id?: string;
  };
  "api.CascadeRegionDetail": {
    /** @description 区域ID */
    id?: string;
    /** @description 该区域下的一级节点 */
    l1_nodes?: definitions["api.CascadeNodeDetail"][];
    /** @description 该区域下的二级节点 */
    l2_nodes?: definitions["api.CascadeNodeDetail"][];
    /** @description 区域名称 */
    name?: string;
  };
  "api.CertInfo": {
    /** @description 申请结果(1:正常, 2:失败, 3:申请中) */
    apply_result?: definitions["constant.CertApplyResult"];
    /** @description 证书品牌 */
    brand?: string;
    /** @description 证书内容 */
    crt?: string;
    /** @description 域名 */
    domain?: string;
    /** @description 生效时间 */
    effective_at?: number;
    /** @description 过期时间 */
    expired_at?: number;
    /** @description 证书id */
    id?: string;
    /** @description 私钥内容 */
    private_key?: string;
  };
  "api.CheckImageCaptchaRequest": {
    /** @description 验证码, 逗号分隔 */
    dots: string;
    /** @description 验证码key */
    key: string;
  };
  "api.ControlNodeRequest": {
    /**
     * @description 控制类型，枚举值之一，例如 start/reload/stop 等，对应以下操作：
     * - start: 启动节点
     * - reload: 重载节点配置
     * - stop: 停止节点
     * - sync: 同步节点配置
     * - restart: 重启节点
     * - uninstall: 卸载节点
     * - purge: 清理缓存，
     * @example start
     * @enum {undefined}
     */
    control_type:
      | "start"
      | "reload"
      | "stop"
      | "sync"
      | "restart"
      | "uninstall"
      | "purge";
    /**
     * @description IDs 节点id列表，必须提供多个节点的 ID
     * @example [
     *   "123456789012345678"
     * ]
     */
    ids: string[];
  };
  "api.ConversionRule": {
    /** @description 条件描述 */
    condition_description?: string;
    /** @description 条件 */
    conditions?: definitions["xcondition.ConditionBase"][];
    /** @description 配置 */
    config?: unknown;
    /** @description 创建时间 */
    created_at?: number;
    /** @description id */
    id?: string;
    /** @description 名称 */
    name?: string;
    /** @description 优先级 */
    priority?: number;
    /** @description 站点ID */
    site_id?: string;
    /** @description 状态(1:启用, 2:禁用) */
    status?: definitions["constant.Status"];
    /** @description 类型(1:URI, 2:请求头, 3:响应头) */
    type?: definitions["constant.ConversionRuleType"];
  };
  "api.CreateACMEAccountRequest": {
    /**
     * @description 算法(1:EC256, 2:EC384, 3:RSA2048, 4:RSA3072, 5:RSA4096)
     * @enum {undefined}
     */
    algorithm: 1 | 2 | 3 | 4 | 5;
    /**
     * @description 账号类型(1:Let's Encrypt, 2:ZeroSSL)
     * @enum {undefined}
     */
    brand: 1 | 2;
    /** @description 邮箱 */
    email: string;
  };
  "api.CreateConversionRuleRequest": {
    /** @description 条件 */
    conditions: definitions["xcondition.ConditionBase"][];
    /**
     * @description 配置
     * URI: {"path": "/abc", "query_string": "?abc=1234"}
     * 请求头: [{"key": "key", "value": "value"}]
     * 响应头: [{"key": "key", "value": "value"}]
     */
    config: unknown;
    /** @description 名称 */
    name: string;
    /** @description 优先级(0: 优先级最低, 1: 优先级最高) */
    priority?: number;
    /** @description 站点ID */
    site_id: string;
    /**
     * @description 类型(1:URI, 2:请求头, 3:响应头)
     * @enum {undefined}
     */
    type?: 1 | 2 | 3;
  };
  "api.CreateDNSApiRequest": {
    /** @description 名称 */
    name: string;
    /**
     * @description DNS服务商 1.独立版 2.Cloudflare 3.阿里云 4.腾讯云
     * @enum {undefined}
     */
    provider: 1 | 2 | 3 | 4;
    /**
     * @description DNS服务商配置
     * 独立版:{"addr":"","app_id":"","app_key":""}
     * Cloudflare:{"api_token":""}
     * 阿里云:{"access_key_id":"","access_key_secret":""}
     * 腾讯云:{"secret_id":"","secret_key":""}
     */
    provider_config: unknown;
  };
  "api.CreateDNSApiResponse": {
    id?: string;
  };
  "api.CreateNodeRequest": {
    /** @description 缓存路径 不能以 /opt/auth-cdn/ 开头 */
    cache_path: string;
    /** @description 缓存大小 示例值： 100MB 100GB 1TB */
    cache_size: string;
    /**
     * @description 节点层级  1 一级节点 2 二级节点
     * @enum {undefined}
     */
    cascade_level: 1 | 2;
    /** @description 是否加入解析 */
    enable_resolve: boolean;
    /** @description Name 节点名称 */
    name: string;
    /** @description RegionID 区域id */
    region_id: string;
  };
  "api.CreateResolveDomainRequest": {
    /** @description dns api id */
    dns_api_id: string;
    /** @description 域名 */
    name: string;
    /** @description 备注 */
    remark?: string;
  };
  "api.CreateResolveRegionRequest": {
    /** @description 区域名字 */
    name: string;
    /** @description 解析域名ID */
    resolve_domain_id: string;
  };
  "api.CreateSiteGroupRequest": {
    name: string;
  };
  "api.CreateSiteGroupResponse": {
    id?: string;
  };
  "api.CreateSiteRequest": {
    /** @description 站点域名 */
    domain: string;
    /** @description 组ID 默认分组传-1 */
    group_id: string;
    /** @description 源站信息 */
    origin_server: definitions["types.OriginServer"];
    /** @description 区域ID */
    region_id: string;
    /** @description 备注信息 */
    remark?: string;
  };
  "api.CreateSiteResponse": {
    /** @description 域名 */
    domain?: string;
    /** @description 站点ID */
    id?: string;
    /** @description 解析信息 */
    resolve_info?: definitions["api.ResolveInfo"];
  };
  "api.CreateWAFRequest": {
    /**
     * @description 动作(1:拦截, 2:跳过, 3:观察, 4:js质询, 5:交互式质询)
     * @enum {undefined}
     */
    action?: 1 | 2 | 3 | 4 | 5;
    /** @description 条件 */
    conditions: definitions["xcondition.ConditionBase"][];
    /**
     * @description 模块(1:自定义, 2:速率限制, 3:白名单)
     * @enum {undefined}
     */
    module?: 1 | 2 | 3;
    /**
     * @description 模块配置
     * 自定义: {}
     * 速率限制: {"count": 100, "cycle": 60s, "duration": 60s}
     * 白名单: {"skip_module": [1, 2, 3]}
     */
    module_config: unknown;
    /** @description 名称 */
    name: string;
    /** @description 优先级(0: 优先级最低, 1: 优先级最高) */
    priority?: number;
    /** @description 响应页 */
    response_page?: definitions["api.ResponsePageInfo"];
    /**
     * @description 范围(2:站点, 3:节点)
     * @enum {undefined}
     */
    scope?: 2 | 3;
    /** @description 站点ID( Scope 为2时必填) */
    site_id?: string;
  };
  "api.DNSApiInfo": {
    /** @description 创建时间 */
    created_at?: number;
    /** @description ID */
    id?: string;
    /** @description 名称 */
    name?: string;
    /** @description DNS服务商 */
    provider?: definitions["constant.DNSProvider"];
    /** @description DNS服务商配置 */
    provider_config?: unknown;
  };
  "api.DeleteACMEAccountRequest": {
    /** @description id */
    id: string;
  };
  "api.DeleteConversionRuleRequest": {
    /** @description id */
    id: string;
  };
  "api.DeleteDNSApiRequest": {
    id: string;
  };
  "api.DeleteDNSApiResponse": { [key: string]: unknown };
  "api.DeleteNodeRequest": {
    /** @description ID 节点id */
    id: string;
  };
  "api.DeleteNodeWAFBindRequest": {
    /** @description nodeid */
    id: string;
    /**
     * @description 模块(1:自定义, 2:速率限制, 3:白名单)
     * @enum {undefined}
     */
    module?: 1 | 2 | 3;
    /** @description wafid */
    waf_ids: string[];
  };
  "api.DeleteResolveDomainRequest": {
    id: string;
  };
  "api.DeleteResolveDomainResponse": { [key: string]: unknown };
  "api.DeleteResolveRegionRequest": {
    id: string;
  };
  "api.DeleteResolveRegionResponse": { [key: string]: unknown };
  "api.DeleteSiteGroupRequest": {
    id: string;
  };
  "api.DeleteWAFBindNodeRequest": {
    /** @description id */
    id: string;
    /** @description 节点ID */
    node_id: string;
  };
  "api.DeleteWAFRequest": {
    id: string;
  };
  "api.GetCacheConfigResponse": {
    cache_config?: definitions["types.CacheConfig"];
  };
  "api.GetCertApplyLogResponse": {
    /** @description 是否结束 */
    is_end?: boolean;
    /** @description 日志内容 */
    message?: string;
  };
  "api.GetDefaultNodeCacheConfigResponse": {
    value?: definitions["types.NodeCacheConfig"];
  };
  "api.GetHTTPPortsRequest": {
    with_default_ports?: boolean;
  };
  "api.GetHTTPPortsResponse": {
    http: string[];
    https: string[];
  };
  "api.GetImageCaptchaResponse": {
    /** @description 验证码图片base64 */
    image_base64?: string;
    /** @description 验证码key */
    key?: string;
    /** @description 缩略图base64 */
    thumb_base64?: string;
  };
  "api.GetLatestVersionResponse": {
    /** @description 版本说明 */
    imprint?: string;
    /** @description 版本号 */
    version?: string;
  };
  "api.GetLicenseResponse": {
    /** @description 授权到期时间 */
    expired_at?: number;
    /** @description 授权码 */
    key?: string;
    /** @description 失败原因 */
    reason?: string;
    /** @description 授权状态 0-未授权 1-正常 2-异常 3-异常（不合法）4-到期 */
    status?: definitions["constant.LicenseStatus"];
  };
  "api.GetMGRAddrResponse": {
    value?: string;
  };
  "api.GetNodeResponse": {
    /** @description CachePath 文件缓存路径 */
    cache_path?: string;
    /** @description CacheSize 缓存大小 */
    cache_size?: string;
    /** @description CascadeIP 级联ip (为空则为使用主IP) */
    cascade_ip?: string;
    /** @description CascadeLevel 节点层级 */
    cascade_level?: definitions["constant.CascadeLevel"];
    /** @description CascadePort 级联端口 */
    cascade_port?: number;
    /** @description CreatedAt 添加时间 */
    created_at?: number;
    /** @description EnableResolve 是否加入解析 */
    enable_resolve?: boolean;
    /** @description ID 节点id */
    id?: string;
    /** @description IPs 节点ip 第一个为主ip */
    ips?: string[];
    /** @description IsRequiresUpgrade 是否需要升级 */
    is_requires_upgrade?: boolean;
    /** @description Name 节点名称 */
    name?: string;
    /** @description RegionInfo 区域信息 */
    region_info?: definitions["api.RegionInfo"];
    /** @description 服务器上报的ip信息 */
    report_ip?: string[];
    /** @description UpdatedAt 更新时间 */
    updated_at?: number;
  };
  "api.GetNodeTreeWithRegionResponse": {
    /** @description List 节点列表 */
    list?: definitions["api.NodeTreeWithRegion"][];
  };
  "api.GetNodeVersionInstallCommandResponse": {
    /** @description 安装命令 */
    command?: string;
  };
  "api.GetPresetCacheRuleResponse": {
    list?: definitions["types.SuffixCacheRule"][];
  };
  "api.GetSimpleNodeRequest": {
    /** @description 区域ID */
    region_id?: string;
  };
  "api.GetSiteAuthorizationResponse": {
    authorization?: definitions["types.Authorization"];
  };
  "api.GetSiteBaseResponse": {
    /** @description 添加时间 */
    created_at?: number;
    /** @description 站点域名 */
    domain?: string;
    /** @description 组信息 默认分组-1 */
    group_info?: definitions["api.GroupInfo"];
    /** @description 站点ID */
    id?: string;
    /** @description 区域信息 */
    region_info?: definitions["api.RegionInfo"];
    /** @description 备注 */
    remark?: string;
    /** @description 解析信息 */
    resolve_info?: definitions["api.ResolveInfo"];
    /** @description 站点状态 */
    status?: definitions["constant.SiteStatus"];
    /** @description 更新时间 */
    updated_at?: number;
  };
  "api.GetSiteCertResponse": {
    /** @description cname记录，如果是泛域名才有 */
    cname?: definitions["types.CNAMEInfo"];
    /** @description 手动证书信息 */
    manual_cert?: definitions["types.SiteCertBase"];
    /** @description 平台证书信息 */
    platform_cert?: definitions["types.SiteCertBase"];
    /** @description 协议 */
    site_cert?: definitions["types.SiteCert"];
  };
  "api.GetSiteHotlinkProtectionResponse": {
    hotlink_protection?: definitions["types.HotlinkProtection"];
  };
  "api.GetSiteOriginServerResponse": {
    /** @description 源站信息 */
    origin_server?: definitions["types.OriginServer"];
  };
  "api.GetSiteSearchEngineResponse": {
    search_engine?: definitions["types.SearchEngine"];
  };
  "api.GetUserResponse": {
    /** @description 用户ID */
    id?: string;
    /** @description 登录时间 */
    login_at?: number;
    /** @description 最近登录IP */
    login_ip?: string;
    /** @description 所在地 */
    login_location?: string;
    /** @description 用户名 */
    username?: string;
  };
  "api.GetWAFResponse": {
    /** @description 动作(1:拦截, 2:跳过, 3:观察, 4:js质询, 5:交互式质询) */
    action?: definitions["constant.WAFAction"];
    /** @description 节点列表 */
    bind_ids?: string[];
    /** @description 条件 */
    conditions?: definitions["xcondition.ConditionBase"][];
    /** @description id */
    id?: string;
    /**
     * @description 模块配置
     * 自定义: {}
     * 速率限制: {"count": 100, "cycle": 60s, "duration": 60s}
     * 白名单: {"skip_module": [1, 2, 3]}
     */
    module_config?: unknown;
    /** @description 名称 */
    name?: string;
    /** @description 优先级(0: 优先级最低, 1: 优先级最高) */
    priority?: number;
    /** @description 响应页 */
    response_page?: definitions["api.ResponsePageInfo"];
  };
  "api.GroupInfo": {
    /** @description 组ID */
    id?: string;
    /** @description 组名称 */
    name?: string;
  };
  "api.InstallRequest": {
    /** @description 管理端地址 [必传] 地址需包含协议头，支持http和https */
    mgr_addr: string;
    /** @description 管理端密码 [必传] 请输入8-20个字符，可包含英文字母、数字和标点符号（除空格） */
    password: string;
    /** @description 管理端密码确认 [必传] 请输入8-20个字符，可包含英文字母、数字和标点符号（除空格） */
    password_confirm: string;
    /** @description 管理端用户名 [必传] 支持英文字母、数字、下划线，长度4-18字符； 不符合规则提示“请输入4-18个字符，可包含英文字母、数字、下划线” */
    username: string;
  };
  "api.ListWAFBindNodeIDResponse": {
    /** @description 节点id */
    node_ids?: string[];
  };
  "api.LoginRequest": {
    /** @description 帐号 */
    account: string;
    /** @description 验证码key */
    captcha_key?: string;
    /** @description 密码 */
    password: string;
  };
  "api.LoginResponse": {
    /** @description token */
    token?: string;
    /** @description 用户信息 */
    user_info?: definitions["api.UserInfo"];
  };
  "api.LookupCNAMEResponse": {
    available?: boolean;
  };
  "api.NeedCaptchaResponse": {
    need_captcha?: boolean;
  };
  "api.NodeDetail": {
    /** @description CascadeLevel 节点层级 */
    cascade_level?: definitions["constant.CascadeLevel"];
    /** @description CreatedAt 添加时间 */
    created_at?: number;
    /** @description ID 节点id */
    id?: string;
    /** @description 是否已经安装 */
    installed?: boolean;
    /** @description IPs 节点ip 第一个为主ip */
    ips?: string[];
    /** @description 是否最新版本 */
    is_latest_version?: boolean;
    /** @description 是否需要升级 */
    is_requires_upgrade?: boolean;
    /** @description Name 节点名称 */
    name?: string;
    /** @description 系统平台信息 */
    platform?: string;
    /** @description 平台版本 */
    platform_version?: string;
    /** @description RegionInfo 区域信息 */
    region_info?: definitions["api.RegionInfo"];
    /** @description 解析状态 */
    resolve_status?: definitions["constant.DNSResolveStatus"];
    /** @description Status 节点运行状态  1 运行 2 异常 3 停止 4 离线 5 初始化 */
    status?: definitions["nodectl.NodeSynthStatus"];
    /** @description UpdatedAt 更新时间 */
    updated_at?: number;
    /** @description Version 版本 */
    version?: string;
  };
  "api.NodeTree": {
    /** @description 级联级别 1 L1节点 2 L2节点 */
    cascade_level?: definitions["constant.CascadeLevel"];
    /** @description ID 节点id */
    id?: string;
    /** @description 节点ips  第一个为主ip */
    ips?: string[];
    /** @description Name 节点名称 */
    name?: string;
  };
  "api.NodeTreeWithRegion": {
    /** @description Nodes 节点列表 */
    nodes?: definitions["api.NodeTree"][];
    /** @description RegionID 区域ID */
    region_id?: string;
    /** @description RegionName 区域名称 */
    region_name?: string;
  };
  "api.ObtainCertRequest": {
    /** @description 强制申请 */
    force?: boolean;
    /** @description 站点ID */
    site_id: string;
  };
  "api.ObtainCertResponse": {
    /** @description 证书id */
    id?: string;
  };
  "api.OverviewResponse": {
    node?: definitions["types.OverviewNode"];
    site?: definitions["types.OverviewSite"];
  };
  "api.QueryACMEAccountResponse": {
    list?: definitions["api.ACMEAccount"][];
  };
  "api.QueryCertInfo": {
    /** @description ACME账户 */
    acme_account_email?: string;
    /** @description 申请结果(1:正常, 2:失败, 3:申请中) */
    apply_result?: definitions["constant.CertApplyResult"];
    /** @description 申请时间 */
    created_at?: number;
    /** @description 跳转标识 */
    flag?: boolean;
    /** @description 证书id */
    id?: string;
    /** @description 站点域名 */
    site_domain?: string;
    /** @description 站点ID */
    site_id?: string;
    /** @description 证书来源(1:手动上传, 2:系统托管) */
    source?: definitions["constant.CertSource"];
  };
  "api.QueryCertResponse": {
    list?: definitions["api.QueryCertInfo"][];
    total?: number;
  };
  "api.QueryConversionRuleResponse": {
    list?: definitions["api.ConversionRule"][];
    total?: number;
  };
  "api.QueryDNSApiResponse": {
    list?: definitions["api.DNSApiInfo"][];
    total?: number;
  };
  "api.QueryNodeRequest": {
    limit?: number;
    /** @description Name 节点名称 */
    name?: string;
    offset?: number;
    /** @enum {string} */
    order?: "asc" | "desc";
    /** @description 主ip */
    primary_ip?: string;
    /** @description RegionID 区域id */
    region_id?: string;
    sort?: string;
    /**
     * @description 节点运行状态  1 运行 2 异常 3 停止 4 离线 5 初始化
     * @enum {undefined}
     */
    status?: 0 | 1 | 2 | 3 | 4 | 5;
  };
  "api.QueryNodeResponse": {
    /** @description List 节点列表 */
    list?: definitions["api.NodeDetail"][];
    /** @description Total 总数 */
    total?: number;
  };
  "api.QueryResolveDomainResponse": {
    list?: definitions["api.ResolveDomainInfo"][];
    total?: number;
  };
  "api.QueryResolveNodeBindingResponse": {
    list?: definitions["api.ResolveNodeBindingInfo"][];
    total?: number;
  };
  "api.QueryResolveRegionResponse": {
    list?: definitions["api.ResolveRegionInfo"][];
    total?: number;
  };
  "api.QueryResolveSiteBindingResponse": {
    list?: definitions["api.ResolveSiteBindingInfo"][];
    total?: number;
  };
  "api.QuerySiteGroupRequest": {
    limit?: number;
    offset?: number;
    /** @enum {string} */
    order?: "asc" | "desc";
    /** @enum {string} */
    sort?: "created_at";
  };
  "api.QuerySiteGroupResponse": {
    list?: definitions["api.SiteGroup"][];
    total?: number;
  };
  "api.QuerySiteList": {
    created_at?: number;
    domain?: string;
    group_info?: definitions["api.GroupInfo"];
    https?: boolean;
    id?: string;
    region_info?: definitions["api.RegionInfo"];
    remark?: string;
    resolve_info?: definitions["api.ResolveInfo"];
    status?: definitions["constant.SiteStatus"];
    updated_at?: number;
  };
  "api.QuerySiteResponse": {
    list?: definitions["api.QuerySiteList"][];
    total?: number;
  };
  "api.QueryWAFConditionResponse": {
    /** @description 条件 */
    list?: definitions["xcondition.ConditionOption"][];
  };
  "api.QueryWAFResponse": {
    list?: definitions["api.WAF"][];
    total?: number;
  };
  "api.RefreshLicenseRequest": { [key: string]: unknown };
  "api.RefreshLicenseResponse": {
    /** @description 授权到期时间 */
    expired_at?: number;
    /** @description 授权码 */
    key?: string;
    /** @description 失败原因 */
    reason?: string;
    /** @description 授权状态 0-未授权 1-正常 2-异常 3-异常（不合法）4-到期 */
    status?: definitions["constant.LicenseStatus"];
  };
  "api.RegionInfo": {
    /** @description 区域ID */
    id?: string;
    /** @description 区域名称 */
    name?: string;
  };
  "api.ReplaceBindLicenseRequest": {
    /** @description 授权码 */
    key: string;
  };
  "api.ReplaceBindLicenseResponse": {
    /** @description 授权到期时间 */
    expired_at?: number;
    /** @description 授权码 */
    key?: string;
    /** @description 失败原因 */
    reason?: string;
    /** @description 授权状态 0-未授权 1-正常 2-异常 3-异常（不合法）4-到期 */
    status?: definitions["constant.LicenseStatus"];
  };
  "api.ResolveDomainInfo": {
    /** @description 创建时间 */
    created_at?: number;
    /** @description dns api id */
    dns_api_id?: string;
    /** @description dns api name */
    dns_api_name?: string;
    /** @description id */
    id?: string;
    /** @description 域名 */
    name?: string;
    /** @description 备注 */
    remark?: string;
  };
  "api.ResolveInfo": {
    /** @description 解析域名id */
    resolve_domain_id?: string;
    /** @description 主机记录 */
    resolve_name?: string;
    /** @description 解析状态 */
    resolve_status?: definitions["constant.DNSResolveStatus"];
    /** @description 记录类型 */
    resolve_type?: definitions["dns.RRType"];
    /** @description 记录值 */
    resolve_value?: string;
  };
  "api.ResolveNodeBindingInfo": {
    /** @description 节点ID */
    node_id?: string;
    /** @description 节点ip */
    node_ip?: string;
    /** @description 节点名称 */
    node_name?: string;
    /** @description 解析状态 */
    provider_rr_status?: definitions["constant.ProviderRRStatus"];
    /** @description 失败原因 */
    provider_rr_status_text?: string;
    /** @description 区域ID */
    region_id?: string;
    /** @description 解析开关 */
    resolve_switch?: definitions["constant.ResolveSwitch"];
    /** @description 更新时间 */
    updated_at?: number;
  };
  "api.ResolveRegionInfo": {
    /** @description Cname */
    cname?: string;
    /** @description 创建时间 */
    created_at?: number;
    /** @description DNS服务商 */
    dns_provider?: definitions["constant.DNSProvider"];
    /** @description id */
    id?: string;
    /** @description 区域名字 */
    name?: string;
    /** @description 节点数量 */
    node_count?: number;
    /** @description 解析域名ID */
    resolve_domain_id?: string;
    /** @description 解析域名 */
    resolve_domain_name?: string;
    /** @description 站点数量 */
    site_count?: number;
  };
  "api.ResolveSiteBindingInfo": {
    /** @description 站点CNAME */
    cname?: string;
    /** @description CNAME域名 */
    full_cname?: string;
    /** @description 解析状态 */
    provider_rr_status?: definitions["constant.ProviderRRStatus"];
    /** @description 失败原因 */
    provider_rr_status_text?: string;
    /** @description 区域ID */
    region_id?: string;
    /** @description 解析域名ID */
    resolve_domain_id?: string;
    /** @description 解析开关 */
    resolve_switch?: definitions["constant.ResolveSwitch"];
    /** @description 站点ID */
    site_id?: string;
    /** @description 站点域名 */
    site_name?: string;
    /** @description 更新时间 */
    updated_at?: number;
  };
  "api.ResponsePageInfo": {
    body?: string;
    code?: number;
    /**
     * @description 类型(1: 默认, 2:HTML, 3:Text, 4:JSON, 5:XML)
     * @enum {undefined}
     */
    type?: 1 | 2 | 3 | 4 | 5;
  };
  "api.SetDefaultNodeCacheConfigRequest": {
    value: definitions["types.NodeCacheConfig"];
  };
  "api.SetHTTPPortsRequest": {
    http: string[];
    https: string[];
  };
  "api.SetMGRAddrRequest": {
    value: string;
  };
  "api.SetPresetCacheRuleRequest": {
    list?: definitions["types.SuffixCacheRule"][];
  };
  "api.SimpleNode": {
    /** @description ID 节点id */
    id?: string;
    /** @description IP 节点IP */
    ip?: string;
    /** @description Name 节点名称 */
    name?: string;
  };
  "api.SiteBandwidthResponse": {
    list?: definitions["types.StatisticSiteBandwidth"][];
  };
  "api.SiteGroup": {
    created_at?: number;
    id?: string;
    name?: string;
    site_count?: number;
  };
  "api.SiteHitRateResponse": {
    list?: definitions["types.StatisticSiteHitRate"][];
  };
  "api.SitePurgeRequest": {
    /** @description 站点ID */
    id: string;
    /**
     * @description 清除类型 1: 全站 2: 指定站点URL
     * @enum {undefined}
     */
    purge_type: 1 | 2;
    /** @description 指定站点URL列表 (最多支持1000个URL，全站时不传) */
    urls?: string[];
  };
  "api.SiteRequestCountResponse": {
    list?: definitions["types.StatisticSiteRequestCount"][];
  };
  "api.SiteSimpleList": {
    domain?: string;
    id?: string;
  };
  "api.SiteTrafficResponse": {
    list?: definitions["types.StatisticSiteTraffic"][];
  };
  "api.StatisticNodeCommonRequest": {
    end_time?: number;
    /** @description 模块(1:自定义 2:速率限制 3:白名单) */
    module?: definitions["constant.WAFModule"];
    node_ids?: string[];
    start_time?: number;
  };
  "api.StatisticNodeCommonResponse": {
    list?: definitions["types.StatisticItem"][];
  };
  "api.StatisticSiteCommonRequest": {
    end_time?: number;
    /** @description 是否首页概览(1:首页概览) */
    is_overview?: number;
    /** @description 模块(1:自定义, 2:速率限制, 3:白名单) */
    module?: definitions["constant.WAFModule"];
    site_ids?: string[];
    start_time?: number;
  };
  "api.SwitchNodeVersionRequest": {
    /** @description 节点id */
    ids: string[];
  };
  "api.TrafficSummaryInfoResponse": {
    top_speed?: number;
    total_bytes?: number;
    total_requests?: number;
  };
  "api.UnbindLicenseRequest": { [key: string]: unknown };
  "api.UnbindLicenseResponse": { [key: string]: unknown };
  "api.UpdateCacheConfigRequest": {
    cache_config: definitions["types.CacheConfig"];
    id: string;
  };
  "api.UpdateConversionRulePriorityRequest": {
    id: string;
    /** @description 优先级 */
    priority?: number;
  };
  "api.UpdateConversionRuleRequest": {
    /** @description 条件 */
    conditions: definitions["xcondition.ConditionBase"][];
    /**
     * @description 配置
     * URI: {"path": "/abc", "query_string": "?abc=1234"}
     * 请求头: [{"key": "key", "value": "value"}]
     * 响应头: [{"key": "key", "value": "value"}]
     */
    config: unknown;
    id: string;
    /** @description 名称 */
    name: string;
    /** @description 优先级(0: 优先级最低, 1: 优先级最高) */
    priority?: number;
  };
  "api.UpdateConversionRuleStatusRequest": {
    id: string;
    /**
     * @description 状态(1:启用, 2:禁用)
     * @enum {undefined}
     */
    status?: 1 | 2;
  };
  "api.UpdateDNSApiRequest": {
    /** @description ID */
    id: string;
    /** @description 名称 */
    name: string;
    /**
     * @description DNS服务商 1.独立版 2.Cloudflare 3.阿里云 4.腾讯云
     * @enum {undefined}
     */
    provider: 1 | 2 | 3 | 4;
    /** @description DNS服务商配置 */
    provider_config: unknown;
  };
  "api.UpdateDNSApiResponse": { [key: string]: unknown };
  "api.UpdateHSTSRequest": {
    /**
     * @description 是否启用HSTS(1:启用, 2:禁用)
     * @enum {undefined}
     */
    hsts_status?: 1 | 2;
    /** @description 站点ID */
    id: string;
  };
  "api.UpdateNodeRequest": {
    /** @description 文件缓存路径 [选传] */
    cache_path?: string;
    /** @description 缓存大小 [选传] 100MB 100GB 1TB */
    cache_size?: string;
    /** @description 级联ip [选传] */
    cascade_ip?: string;
    /**
     * @description 节点层级  1 一级节点 2 二级节点 [选传]
     * @enum {undefined}
     */
    cascade_level?: 1 | 2;
    /** @description 级联端口 [选传] 1024 至 65535 不能等于 agent 的端口 */
    cascade_port?: number;
    /** @description 是否加入解析 [选传] */
    enable_resolve?: boolean;
    /** @description ID 节点id [必传] */
    id: string;
    /** @description 节点ip 第一个为主ip [选传] */
    ips?: string[];
    /** @description Name 节点名称 [选传] */
    name?: string;
    /** @description RegionID 区域id [选传] */
    region_id?: string;
  };
  "api.UpdateResolveDomainRequest": {
    /** @description dns api id */
    dns_api_id: string;
    /** @description id */
    id: string;
    /** @description 域名 */
    name: string;
    /** @description 备注 */
    remark?: string;
  };
  "api.UpdateResolveRegionRequest": {
    /** @description Cname region-前缀, 后面为6-20位字母和数字 region-[A-Za-z1-9]{6,20},总长度为13-27 */
    cname?: string;
    /** @description 区域ID */
    id: string;
    /** @description 区域名字 */
    name?: string;
    /** @description 解析域名ID10 */
    resolve_domain_id: string;
  };
  "api.UpdateSiteAuthorizationRequest": {
    authorization: definitions["types.Authorization"];
    id: string;
  };
  "api.UpdateSiteBaseRequest": {
    /** @description CNAME域名 */
    cname_domain?: definitions["types.CNAMEDomain"];
    /** @description 组ID 默认分组传-1  0表示全部分组 */
    group_id?: string;
    /** @description 站点ID */
    id: string;
    /** @description 区域ID */
    region_id?: string;
    /** @description 备注 */
    remark?: string;
    /**
     * @description 站点状态
     * @enum {undefined}
     */
    status?: 1 | 2;
  };
  "api.UpdateSiteCertRequest": {
    /** @description 强制https端口 */
    force_https_port?: number;
    /**
     * @description 是否启用HSTS(1:启用, 2:禁用)
     * @enum {undefined}
     */
    hsts_status?: 0 | 1 | 2;
    /**
     * @description 仅http:
     * 		EnableHTTP = 1, EnableHTTPS = 2
     * 强制https:
     * 		EnableHTTP = 2, EnableHTTPS = 1
     * HTTP+HTTPS:
     * 		EnableHTTP = 1, EnableHTTPS = 1
     * @enum {undefined}
     */
    http_status?: 0 | 1 | 2;
    /**
     * @description 是否启用https(1:启用, 2:禁用)
     * @enum {undefined}
     */
    https_status?: 0 | 1 | 2;
    /** @description 站点ID */
    id: string;
    /**
     * @description 证书来源
     * @enum {undefined}
     */
    source: 1 | 2;
  };
  "api.UpdateSiteCompressionRequest": {
    /** @description 站点ID */
    id: string;
    /** @description 站点压缩配置(css, js, html) */
    site_compression: definitions["types.SiteCompression"];
  };
  "api.UpdateSiteGroupRequest": {
    id: string;
    name: string;
  };
  "api.UpdateSiteHotlinkProtectionRequest": {
    hotlink_protection: definitions["types.HotlinkProtection"];
    id: string;
  };
  "api.UpdateSiteOriginServerRequest": {
    /** @description 站点ID */
    id: string;
    /** @description 源站信息 */
    origin_server: definitions["types.OriginServer"];
  };
  "api.UpdateSiteResolveStatusRequest": {
    id: string;
  };
  "api.UpdateSiteResolveStatusResponse": {
    /** @description 解析状态 */
    resolve_status?: definitions["constant.DNSResolveStatus"];
  };
  "api.UpdateSiteSearchEngineRequest": {
    id: string;
    search_engine: definitions["types.SearchEngine"];
  };
  "api.UpdateUserPasswordRequest": {
    /** @description 确认密码 */
    confirm_password: string;
    /** @description 新密码 */
    new_password: string;
    /** @description 旧密码 */
    old_password: string;
  };
  "api.UpdateUserPasswordResponse": { [key: string]: unknown };
  "api.UpdateUserRequest": {
    /** @description 用户名 */
    username: string;
  };
  "api.UpdateUserResponse": { [key: string]: unknown };
  "api.UpdateVersionRequest": {
    /** @description 版本号 */
    version?: string;
  };
  "api.UpdateWAFBindRequest": {
    /** @description wafid */
    id: string;
    /** @description 节点id */
    node_ids?: string[];
  };
  "api.UpdateWAFPriorityRequest": {
    /** @description id */
    id: string;
    /** @description 优先级 */
    priority?: number;
  };
  "api.UpdateWAFRequest": {
    /**
     * @description 动作(1:拦截, 2:跳过, 3:观察, 4:js质询, 5:交互式质询)
     * @enum {undefined}
     */
    action?: 1 | 2 | 3 | 4 | 5;
    /** @description 条件 */
    conditions: definitions["xcondition.ConditionBase"][];
    /** @description id */
    id: string;
    /**
     * @description 模块配置
     * 自定义: {}
     * 速率限制: {"count": 100, "cycle": 60s, "duration": 60s}
     * 白名单: {"skip_module": [1, 2, 3]}
     */
    module_config: unknown;
    /** @description 名称 */
    name: string;
    /** @description 优先级(0: 优先级最低, 1: 优先级最高) */
    priority?: number;
    /** @description 响应页 */
    response_page?: definitions["api.ResponsePageInfo"];
  };
  "api.UpdateWAFStatusRequest": {
    /** @description id */
    id: string;
    /**
     * @description 状态(1:启用, 2:禁用)
     * @enum {undefined}
     */
    status?: 1 | 2;
  };
  "api.UploadCertRequest": {
    /** @description 证书内容 */
    crt: string;
    /** @description 证书私钥 */
    private_key: string;
    /** @description 站点ID */
    site_id: string;
  };
  "api.UserInfo": {
    /** @description 用户ID */
    id?: string;
    /** @description 登录时间 */
    login_at?: number;
    /** @description 最近登录IP */
    login_ip?: string;
    /** @description 所在地 */
    login_location?: string;
    /** @description 用户名 */
    username?: string;
  };
  "api.VersionResponse": {
    /** @description 是否可更新 */
    can_update?: boolean;
    /** @description 当前系统版本 */
    current_version?: string;
    /** @description 最新版本说明 */
    last_version_release?: string;
    /** @description 最新系统版本 */
    latest_version?: string;
  };
  "api.WAF": {
    /** @description 动作(1:拦截, 2:跳过, 3:观察, 4:js质询, 5:交互式质询) */
    action?: definitions["constant.WAFAction"];
    /** @description 条件描述 */
    condition_description?: string;
    /** @description 创建时间 */
    created_at?: number;
    /** @description id */
    id?: string;
    /**
     * @description 模块配置
     * 自定义: {}
     * 速率限制: {"count": 100, "cycle": 60s, "duration": 60s}
     * 白名单: {"skip_module": [1, 2, 3]}
     */
    module_config?: unknown;
    /** @description 名称 */
    name?: string;
    /** @description 节点绑定数量 */
    node_bind_count?: number;
    /** @description 优先级 */
    priority?: number;
    /** @description 状态(1:启用, 2:禁用) */
    status?: definitions["constant.Status"];
  };
  "api.WafInfoResponse": {
    map?: { [key: string]: definitions["types.StatisticWafInfo"] };
  };
  "api.WafNodeLogRequest": {
    /** @description 采取措施(1:拦截 2:跳过 3:观察 4:JS质询 5:交互式质询) */
    action?: definitions["constant.WAFAction"];
    /** @description 结束时间 */
    end_time?: number;
    /** @description 站点ID/节点ID */
    id?: string;
    /** @description 请求ip */
    ip?: string;
    limit?: number;
    /** @description 请求方法 */
    method?: string;
    /** @description 规则类型(1:自定义规则 2:速率限制 3:白名单) */
    module?: definitions["constant.WAFModule"];
    /** @description 站点名称/节点名称 */
    name?: string;
    node_ip?: string;
    offset?: number;
    /** @enum {string} */
    order?: "asc" | "desc";
    /** @description 请求地区 */
    rep_region?: string;
    sort?: string;
    /** @description 开始时间 */
    start_time?: number;
    /** @description URL */
    url?: string;
    /** @description 规则ID */
    waf_id?: string;
    /** @description 规则名称 */
    waf_name?: string;
  };
  "api.WafNodeLogResponse": {
    list?: definitions["types.StatisticWafNodeLog"][];
    total?: number;
  };
  "api.WafRuleResponse": {
    list?: definitions["types.StatisticWafRule"][];
  };
  "api.WafSiteLogRequest": {
    /** @description 采取措施(1:拦截 2:跳过 3:观察 4:JS质询 5:交互式质询) */
    action?: definitions["constant.WAFAction"];
    /** @description 结束时间 */
    end_time?: number;
    /** @description 站点ID/节点ID */
    id?: string;
    /** @description 请求ip */
    ip?: string;
    limit?: number;
    /** @description 请求方法 */
    method?: string;
    /** @description 规则类型(1:自定义规则 2:速率限制 3:白名单) */
    module?: definitions["constant.WAFModule"];
    /** @description 站点名称/节点名称 */
    name?: string;
    offset?: number;
    /** @enum {string} */
    order?: "asc" | "desc";
    /** @description 请求地区 */
    rep_region?: string;
    sort?: string;
    /** @description 开始时间 */
    start_time?: number;
    /** @description URL */
    url?: string;
    /** @description 规则ID */
    waf_id?: string;
    /** @description 规则名称 */
    waf_name?: string;
  };
  "api.WafSiteLogResponse": {
    list?: definitions["types.StatisticWafLog"][];
    total?: number;
  };
  /** @enum {integer} */
  "constant.AuthenticationScope": 1 | 2 | 3;
  /** @enum {integer} */
  "constant.AuthorizationType": 1 | 2 | 3 | 4;
  /** @enum {integer} */
  "constant.CascadeLevel": 0 | 1 | 2;
  /** @enum {integer} */
  "constant.CertAlgorithm": 1 | 2 | 3 | 4 | 5;
  /** @enum {integer} */
  "constant.CertApplyResult": 1 | 2 | 3;
  /** @enum {integer} */
  "constant.CertBrand": 1 | 2;
  /** @enum {integer} */
  "constant.CertSource": 1 | 2;
  /** @enum {integer} */
  "constant.ConversionRuleType": 1 | 2 | 3;
  /** @enum {integer} */
  "constant.DNSProvider": 1 | 2 | 3 | 4;
  /** @enum {integer} */
  "constant.DNSResolveStatus": 1 | 2;
  /** @enum {integer} */
  "constant.HotlinkProtectionFileType": 1 | 2 | 3;
  /** @enum {integer} */
  "constant.HotlinkProtectionMode": 1 | 2;
  /** @enum {integer} */
  "constant.LicenseStatus": 0 | 1 | 2 | 3 | 4;
  /** @enum {string} */
  "constant.OriginAlgorithm": "round_robin" | "chash" | "swrr";
  /** @enum {string} */
  "constant.OriginProtocol": "http" | "https";
  /** @enum {integer} */
  "constant.ProviderRRStatus": 1 | 2 | 3;
  /** @enum {integer} */
  "constant.PurgeType": 1 | 2;
  /** @enum {integer} */
  "constant.ResolveSwitch": 1 | 2;
  /** @enum {integer} */
  "constant.ResponsePageType": 1 | 2 | 3 | 4 | 5;
  /** @enum {integer} */
  "constant.SiteStatus": 1 | 2;
  /** @enum {integer} */
  "constant.Status": 1 | 2;
  /** @enum {integer} */
  "constant.WAFAction": 1 | 2 | 3 | 4 | 5;
  /** @enum {integer} */
  "constant.WAFModule": 1 | 2 | 3;
  /** @enum {integer} */
  "constant.WAFScope": 1 | 2 | 3;
  /** @enum {string} */
  "dns.RRType": "A" | "CNAME" | "TXT";
  /** @enum {integer} */
  "nodectl.ComponentStatus": 0 | 1 | 2 | 3;
  /** @enum {string} */
  "nodectl.ControlAction":
    | "start"
    | "reload"
    | "stop"
    | "sync"
    | "restart"
    | "uninstall"
    | "purge"
    | "switch_version"
    | "manager_addr";
  "nodectl.FormattedInfo": {
    agent_status?: definitions["nodectl.ComponentStatus"];
    ips?: string[];
    node_id?: string;
    openresty_status?: definitions["nodectl.ComponentStatus"];
    /** @description 主IP 仅第一次获取 */
    primary_ip?: string;
    system_info?: definitions["nodectl.SystemInfo"];
    version?: string;
  };
  /** @enum {integer} */
  "nodectl.NodeSynthStatus": 0 | 1 | 2 | 3 | 4 | 5;
  "nodectl.SystemInfo": {
    /** @description 系统架构 */
    arch?: string;
    /** @description 主机名 */
    hostname?: string;
    /** @description 内核版本 */
    kernel?: string;
    /** @description 操作系统 */
    os?: string;
    /** @description 平台 */
    platform?: string;
    /** @description 平台版本 */
    platform_version?: string;
  };
  "types.Authorization": {
    /**
     * @description 是否开启 1.开启 2.关闭
     * @enum {undefined}
     */
    status: 1 | 2;
    /** @description 鉴权类型 1:a 2:b 3:c 4:d */
    type?: definitions["constant.AuthorizationType"];
    /** @description 鉴权类型A */
    type_a?: definitions["types.AuthorizationTypeA"];
    /** @description 鉴权类型B */
    type_b?: definitions["types.AuthorizationTypeB"];
    /** @description 鉴权类型C */
    type_c?: definitions["types.AuthorizationTypeC"];
    /** @description 鉴权类型D */
    type_d?: definitions["types.AuthorizationTypeD"];
  };
  "types.AuthorizationTypeA": {
    /** @description 文件后缀列表 */
    file_suffix_list?: string[];
    /** @description 鉴权范围 1.全部 2.指定后缀鉴权 3.指定后缀不鉴权 */
    scope?: definitions["constant.AuthenticationScope"];
    /** @description 密钥 6-40位大小写字母 */
    secret_key?: string;
    /** @description 签名参数 */
    signature_parameter?: string;
    /** @description 有效时间 1-630720000 */
    ttl?: number;
  };
  "types.AuthorizationTypeB": {
    /** @description 文件后缀列表 */
    file_suffix_list?: string[];
    /** @description 鉴权范围 1.全部 2.指定后缀鉴权 3.指定后缀不鉴权 */
    scope?: definitions["constant.AuthenticationScope"];
    /** @description 密钥 6-40位大小写字母 */
    secret_key?: string;
    /** @description 有效时间 1-630720000 */
    ttl?: number;
  };
  "types.AuthorizationTypeC": {
    /** @description 文件后缀列表 */
    file_suffix_list?: string[];
    /** @description 鉴权范围 1.全部 2.指定后缀鉴权 3.指定后缀不鉴权 */
    scope?: definitions["constant.AuthenticationScope"];
    /** @description 密钥 6-40位大小写字母 */
    secret_key?: string;
    /** @description 有效时间 1-630720000 */
    ttl?: number;
  };
  "types.AuthorizationTypeD": {
    /** @description 文件后缀列表 */
    file_suffix_list?: string[];
    /** @description 鉴权范围 1.全部 2.指定后缀鉴权 3.指定后缀不鉴权 */
    scope?: definitions["constant.AuthenticationScope"];
    /** @description 密钥 6-40位大小写字母 */
    secret_key?: string;
    /** @description 签名参数 */
    signature_parameter?: string;
    /** @description 时间戳格式 10 or 16 */
    timestamp_format?: number;
    /** @description 时间戳参数名 */
    timestamp_parameter?: string;
    /** @description 有效时间 1-630720000 */
    ttl?: number;
  };
  "types.CNAMEDomain": {
    /** @description CNAME名 （需包含site-开头) */
    cname: string;
    /** @description 解析域名ID */
    resolve_domain_id: string;
  };
  "types.CNAMEInfo": {
    name?: string;
    target?: string;
    type?: string;
  };
  "types.CacheConfig": {
    /** @description 自定义浏览器缓存开关 为false 即为遵循源站 */
    browser_cache_enable?: boolean;
    /** @description 自定义浏览器缓存时间 1m 1h 1d 1s */
    browser_cache_time?: string;
    /** @description 忽略查询字符串 */
    ignore_query_string?: boolean;
    /** @description 首页缓存开关 */
    index_cache_enable?: boolean;
    /** @description 首页缓存时间 1m 1h 1d 1s */
    index_cache_time?: string;
    /** @description 后缀缓存规则 */
    suffix_cache_rule?: definitions["types.SuffixCacheRule"][];
  };
  "types.HotlinkProtection": {
    /** @description 空Referer允许状态 1.允许 2.不允许 */
    empty_referer_allow_status?: definitions["constant.Status"];
    /** @description 文件路径列表 */
    file_path_list?: string[];
    /** @description 文件后缀列表 */
    file_suffix_list?: string[];
    /** @description 文件类型 1.所有文件 2.文件后缀 3.文件路径 */
    file_type?: definitions["constant.HotlinkProtectionFileType"];
    /** @description 模式 1.黑名单 2.白名单 */
    mode?: definitions["constant.HotlinkProtectionMode"];
    /** @description 匹配列表 */
    referer_host_list?: string[];
    /**
     * @description 是否开启 1.开启 2.关闭
     * @enum {undefined}
     */
    status: 1 | 2;
  };
  "types.NodeCacheConfig": {
    /** @description 缓存路径 不能以 /opt/auth-cdn/ 开头 */
    cache_path: string;
    /** @description 缓存大小 示例值： 100MB 100GB 1TB */
    cache_size: string;
  };
  "types.OriginList": {
    /** @description 主机 */
    host: string;
    /** @description 端口 */
    port: number;
    /** @description 优先级 非权重时为0 */
    priority: number;
  };
  "types.OriginServer": {
    /**
     * @description 算法
     * @enum {undefined}
     */
    algorithm: "chash" | "round_robin" | "swrr";
    /** @description 回源域名 */
    origin_host?: string;
    /** @description 回源列表 */
    origin_list?: definitions["types.OriginList"][];
    /**
     * @description 协议
     * @enum {undefined}
     */
    protocol: "http" | "https";
  };
  "types.OverviewNode": {
    /** @description 异常节点数 */
    abnormal?: number;
    /** @description 离线节点数 */
    offline?: number;
    /** @description 运行中节点数 */
    running?: number;
    /** @description 停止节点数 */
    stopped?: number;
    /** @description 节点总数 */
    total?: number;
  };
  "types.OverviewSite": {
    /** @description 解析数 */
    resolved?: number;
    /** @description 站点总数 */
    total?: number;
    /** @description 未解析数 */
    unresolved?: number;
  };
  "types.SearchEngine": {
    /**
     * @description 爬虫限制状态
     * @enum {undefined}
     */
    robot_deny_status: 1 | 2;
  };
  "types.SiteCert": {
    /** @description 强制https端口 */
    force_https_port?: number;
    /** @description 是否启用HSTS(1:启用, 2:禁用) */
    hsts_status?: definitions["constant.Status"];
    /**
     * @description 仅http:
     * 		EnableHTTP = 1, EnableHTTPS = 2
     * 强制https:
     * 		EnableHTTP = 2, EnableHTTPS = 1
     * HTTP+HTTPS:
     * 		EnableHTTP = 1, EnableHTTPS = 1
     */
    http_status?: definitions["constant.Status"];
    /** @description 是否启用https(1:启用, 2:禁用) */
    https_status?: definitions["constant.Status"];
    /** @description 手动证书id */
    manual_cert_id?: string;
    /** @description 平台证书id */
    platform_cert_id?: string;
    /** @description 证书来源 */
    source?: definitions["constant.CertSource"];
  };
  "types.SiteCertBase": {
    /** @description 申请结果(1:正常, 2:失败, 3:申请中) */
    apply_result?: definitions["constant.CertApplyResult"];
    /** @description 证书品牌 */
    brand?: string;
    /** @description 错误信息 */
    error_msg?: string;
    /** @description 过期时间 */
    expired_at?: number;
    /** @description 证书ID */
    id?: string;
  };
  "types.SiteCompression": {
    brotli?: string[];
    gzip?: string[];
  };
  "types.StatisticItem": {
    list?: definitions["types.StatisticMetric"][];
    node_name?: string;
  };
  "types.StatisticMetric": {
    time?: number;
    value?: number;
  };
  "types.StatisticSiteBandwidth": {
    bandwidth?: number;
    time?: number;
  };
  "types.StatisticSiteHitRate": {
    request_hit_rate?: number;
    time?: number;
    traffic_hit_rate?: number;
  };
  "types.StatisticSiteRequestCount": {
    hit_request_count_total?: number;
    request_count_total?: number;
    time?: number;
  };
  "types.StatisticSiteTraffic": {
    bytes_total?: number;
    hit_bytes_total?: number;
    origin_bytes_total?: number;
    time?: number;
  };
  "types.StatisticWafInfo": {
    block_cnt?: number;
    log_cnt?: number;
    total?: number;
  };
  "types.StatisticWafLog": {
    /** @description 采取措施(1:拦截 2:跳过 3:观察 4:JS质询 5:交互式质询) */
    action?: definitions["constant.WAFAction"];
    /** @description 浏览器 */
    browser?: string;
    /** @description http版本 */
    http_version?: string;
    /** @description 站点ID/节点ID */
    id?: string;
    /** @description 请求ip */
    ip?: string;
    /** @description 请求方法 */
    method?: string;
    /** @description 规则类型(1:自定义规则 2:速率限制 3:白名单) */
    module?: definitions["constant.WAFModule"];
    /** @description 站点名称/节点名称 */
    name?: string;
    /** @description 站点区域/节点区域 */
    region?: string;
    /** @description 请求地区 */
    rep_region?: string;
    /** @description 请求协议 */
    scheme?: string;
    /** @description 时间戳 */
    time?: number;
    /** @description URL */
    url?: string;
    /** @description 规则ID */
    waf_id?: string;
    /** @description 规则名称 */
    waf_name?: string;
  };
  "types.StatisticWafNodeLog": {
    /** @description 采取措施(1:拦截 2:跳过 3:观察 4:JS质询 5:交互式质询) */
    action?: definitions["constant.WAFAction"];
    /** @description 浏览器 */
    browser?: string;
    /** @description http版本 */
    http_version?: string;
    /** @description 站点ID/节点ID */
    id?: string;
    /** @description 请求ip */
    ip?: string;
    /** @description 请求方法 */
    method?: string;
    /** @description 规则类型(1:自定义规则 2:速率限制 3:白名单) */
    module?: definitions["constant.WAFModule"];
    /** @description 站点名称/节点名称 */
    name?: string;
    node_ip?: string;
    /** @description 站点区域/节点区域 */
    region?: string;
    /** @description 请求地区 */
    rep_region?: string;
    /** @description 请求协议 */
    scheme?: string;
    /** @description 时间戳 */
    time?: number;
    /** @description URL */
    url?: string;
    /** @description 规则ID */
    waf_id?: string;
    /** @description 规则名称 */
    waf_name?: string;
  };
  "types.StatisticWafRule": {
    block_cnt?: number;
    log_cnt?: number;
    time?: number;
  };
  "types.SuffixCacheRule": {
    /** @description 缓存时间 1m 1h 1d 1s */
    cache_time: string;
    /** @description 后缀 */
    suffix?: string[];
  };
  "types.UpdateInfo": {
    /** @description 错误信息 */
    error?: string;
    /** @description 升级进度 0 升级中 1 升级失败 2 升级成功 */
    progress?: number;
  };
  "xcondition.ConditionBase": {
    /** @description 自定义字段 */
    custom_field?: string;
    /** @description 字段 */
    field?: definitions["xcondition.conditionField"];
    /** @description 操作符 */
    operator?: definitions["xcondition.conditionOperator"];
    /** @description 值 */
    value?: string[];
  };
  "xcondition.ConditionOption": {
    /** @description 允许的值，如果运算符有限制，则使用运算符的，否则使用当前的 */
    allowed_values?: definitions["xcondition.Display"][];
    /** @description 字段 */
    field?: definitions["xcondition.FieldDisplay"];
    /** @description 该字段支持的操作符列表 */
    operators?: definitions["xcondition.OperatorDisplay"][];
  };
  "xcondition.Display": {
    /** @description 后端接收字段 */
    field?: unknown;
    /** @description 前端展示字段 */
    show_name?: string;
  };
  "xcondition.FieldDisplay": {
    /** @description 自定义字段的示例 */
    custom_field_example?: string;
    /** @description 后端接收字段 */
    field?: unknown;
    /** @description 需要自定义字段 */
    need_custom_field?: boolean;
    /** @description 前端展示字段 */
    show_name?: string;
  };
  "xcondition.OperatorDisplay": {
    /** @description 允许的值，若为空则不限制 */
    allowed_values?: definitions["xcondition.Display"][];
    /** @description 后端接收字段 */
    field?: unknown;
    /** @description 前端展示字段 */
    show_name?: string;
    /** @description 值 */
    value?: definitions["xcondition.Value"];
  };
  "xcondition.Value": {
    /** @description 值的数量 */
    count?: number;
    /** @description 示例值 */
    example?: string;
    /** @description 长度/值的最大值 */
    max?: number;
    /** @description 长度/值的最小值 */
    min?: number;
    /** @description 值的类型(string, int) */
    type?: definitions["xcondition.conditionValueType"];
  };
  /** @enum {string} */
  "xcondition.conditionField":
    | "uri"
    | "path"
    | "ip"
    | "referer"
    | "user_agent"
    | "cookie"
    | "host"
    | "method"
    | "query_string"
    | "http_version"
    | "x_forwarded_for"
    | "content_type"
    | "content_length"
    | "header"
    | "file_ext"
    | "filename"
    | "query_string_param"
    | "cookie_name"
    | "server_port"
    | "continent"
    | "country";
  /** @enum {string} */
  "xcondition.conditionOperator":
    | "eq"
    | "neq"
    | "gt"
    | "lt"
    | "gte"
    | "lte"
    | "contain"
    | "not_contain"
    | "in"
    | "not_in"
    | "regex"
    | "not_regex"
    | "len_eq"
    | "len_neq"
    | "len_gt"
    | "len_lt"
    | "len_gte"
    | "len_lte"
    | "prefix"
    | "not_prefix"
    | "suffix"
    | "not_suffix"
    | "nil"
    | "not_nil"
    | "times";
  /** @enum {string} */
  "xcondition.conditionValueType": "int";
}

export interface operations {}

export interface external {}
